home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / prgtools / gnustuff / tos / updates / update20.zoo / util / diffs
Encoding:
Text File  |  1992-04-19  |  34.0 KB  |  1,449 lines
  1. *** 1.26    1992/03/22 21:44:03
  2. --- Changelog    1992/04/19 17:00:12
  3. ***************
  4. *** 272,274 ****
  5. --- 272,297 ----
  6.       free demangled storage.
  7.   
  8.   ----------------------------- Patchlevel 26 ---------------------------------
  9. + 
  10. + ld.c:: Michal
  11. +     clean up compiler noise.
  12. + 
  13. + cnm.c:: andreas
  14. +         adjust proto for ckfread; correctly count symbols if
  15. +     WORD_ALIGNED
  16. + 
  17. + cplusdem.c:: andreas
  18. +         some names couldn't be demangled (like template
  19. +     functions, static members)
  20. + 
  21. + ld.c:: andreas
  22. +         adjust protos for mywrite, xmalloc, xrealloc;
  23. +     initialize gst_symboltable and gst_symbols if CROSSATARI
  24. + 
  25. + strip.c:: andreas
  26. +         preserve long symbols, avoid warnings about cast
  27. + 
  28. + sym-ld.c:: andreas
  29. +          write only the symbols since this is all what gdb needs
  30. + 
  31. + ----------------------------- Patchlevel 27 ---------------------------------
  32. *** 1.24    1992/03/22 21:44:03
  33. --- PatchLev.h    1992/04/19 17:00:13
  34. ***************
  35. *** 1,4 ****
  36. ! #define PatchLevel "26"
  37.   
  38.   /*
  39.    *    the Patch Level above is to identify the version
  40. --- 1,4 ----
  41. ! #define PatchLevel "27"
  42.   
  43.   /*
  44.    *    the Patch Level above is to identify the version
  45. *** 1.5    1992/01/14 19:45:23
  46. --- cnm.c    1992/04/19 17:00:14
  47. ***************
  48. *** 81,87 ****
  49.   int fill8 P_((char *s));
  50.   int not_glob P_((int x));
  51.   void sflags P_((int x));
  52. ! void ckfread P_((char *buf, int siz, int n, FILE *fp));
  53.   int readhead P_((struct hdr *h, int n, FILE *fd));
  54.   int readsyms P_((struct xsym *syms, int n, FILE *fd));
  55.   
  56. --- 81,87 ----
  57.   int fill8 P_((char *s));
  58.   int not_glob P_((int x));
  59.   void sflags P_((int x));
  60. ! void ckfread P_((void *buf, int siz, int n, FILE *fp));
  61.   int readhead P_((struct hdr *h, int n, FILE *fd));
  62.   int readsyms P_((struct xsym *syms, int n, FILE *fd));
  63.   
  64. ***************
  65. *** 230,236 ****
  66. --- 230,240 ----
  67.       }
  68.       len = h.tsize + h.dsize;
  69.       fseek(fd, len, 1);
  70. + #ifndef WORD_ALIGNED
  71.       return h.syms / sizeof(struct sym);
  72. + #else
  73. +     return h.syms / 14;
  74. + #endif
  75.   }
  76.   
  77.   void
  78. ***************
  79. *** 315,321 ****
  80.   
  81.   #ifdef WORD_ALIGNED
  82.   void ckfread(buf, siz, n, fp)
  83. ! char *buf;
  84.   int siz, n;
  85.   FILE *fp;
  86.   {
  87. --- 319,325 ----
  88.   
  89.   #ifdef WORD_ALIGNED
  90.   void ckfread(buf, siz, n, fp)
  91. ! void *buf;
  92.   int siz, n;
  93.   FILE *fp;
  94.   {
  95. *** 1.2    1992/03/08 17:23:52
  96. --- cplusdem.c    1992/04/19 17:00:15
  97. ***************
  98. *** 166,171 ****
  99. --- 166,177 ----
  100.     "cm", ",",            /* ansi */
  101.     "nop", "",            /* old (for operator=) */
  102.     "as", "=",            /* ansi */
  103. +   "cond", "?:",            /* old */
  104. +   "cn", "?:",            /* psuedo-ansi */
  105. +   "max", ">?",            /* old */
  106. +   "mx", ">?",            /* psuedo-ansi */
  107. +   "min", "<?",            /* old */
  108. +   "mn", "<?",            /* psuedo-ansi */
  109.   };
  110.   
  111.   /* Beware: these aren't '\0' terminated. */
  112. ***************
  113. *** 186,194 ****
  114.   static void string_appends (string *p, string *s);
  115.   static void string_appendn (string *p, const char *s, int n);
  116.   static void string_prepend (string *p, const char *s);
  117. - #if 0
  118.   static void string_prepends (string *p, string *s);
  119. - #endif
  120.   static void string_prependn (string *p, const char *s, int n);
  121.   static int get_count (const char **type, int *count);
  122.   static int do_args (const char **type, string *decl);
  123. --- 192,198 ----
  124. ***************
  125. *** 195,200 ****
  126. --- 199,207 ----
  127.   static int do_type (const char **type, string *result);
  128.   static int do_arg (const char **type, string *result);
  129.   static int do_args (const char **type, string *decl);
  130. + static int do_cuv_prefix (const char **type, string *result, int *non_empty);
  131. + static int do_builtin_type (const char **type, string *result, int *non_empty);
  132. + static int do_template_args (const char **type, string *result);
  133.   static void munge_function_name (string *name);
  134.   static void remember_type (const char *type, int len);
  135.   #else
  136. ***************
  137. *** 214,219 ****
  138. --- 221,229 ----
  139.   static int do_type ();
  140.   static int do_arg ();
  141.   static int do_args ();
  142. + static int do_cuv_prefix ();
  143. + static int do_builtin_type ();
  144. + static int do_template_args ();
  145.   static void munge_function_name ();
  146.   static void remember_type ();
  147.   #endif
  148. ***************
  149. *** 275,286 ****
  150.         destructor = 1;
  151.         p = type;
  152.       }
  153. -       /* static data member */
  154. -       else if (*type != '_' && (strchr (type, CPLUS_MARKER) != NULL))
  155. -     {
  156. -       static_type = 1;
  157. -       p = type;
  158. -     }
  159.         /* virtual table "_vt$"  */
  160.         else if (type[0] == '_' && type[1] == 'v' && type[2] == 't' && type[3] == CPLUS_MARKER)
  161.       {
  162. --- 285,290 ----
  163. ***************
  164. *** 290,295 ****
  165. --- 294,305 ----
  166.         strcat (tem, " virtual table");
  167.         return tem;
  168.       }
  169. +       /* static data member */
  170. +       else if (type[0] == '_' && type[1] != '_' && (strchr (type, CPLUS_MARKER) != NULL))
  171. +     {
  172. +       static_type = 1;
  173. +       p = type + 1;
  174. +     }
  175.         else return NULL;
  176.       }
  177.   
  178. ***************
  179. *** 323,334 ****
  180.         string_appendn (&decl, "", 1);
  181.         munge_function_name (&decl);
  182.         if (decl.b[0] == '_')
  183. !         {
  184. !           string_delete (&decl);
  185. !           return NULL;
  186. !         }
  187. !       else
  188. !         p += 2;
  189.       }
  190.         else
  191.       {
  192. --- 333,340 ----
  193.         string_appendn (&decl, "", 1);
  194.         munge_function_name (&decl);
  195.         if (decl.b[0] == '_')
  196. !         decl.p--;
  197. !       p += 2;
  198.       }
  199.         else
  200.       {
  201. ***************
  202. *** 351,363 ****
  203.       {
  204.       case 'C':
  205.         /* a const member function */
  206. !       if (!isdigit (p[1]))
  207.       {
  208.         string_delete (&decl);
  209.         return NULL;
  210.       }
  211. -       p += 1;
  212. -       const_flag = 1;
  213.         /* fall through */
  214.       case '0':
  215.       case '1':
  216. --- 357,371 ----
  217.       {
  218.       case 'C':
  219.         /* a const member function */
  220. !       p += 1;
  221. !       const_flag = 1;
  222. !       if (*p == 't')
  223. !     goto template;
  224. !       if (!isdigit (*p))
  225.       {
  226.         string_delete (&decl);
  227.         return NULL;
  228.       }
  229.         /* fall through */
  230.       case '0':
  231.       case '1':
  232. ***************
  233. *** 416,597 ****
  234.         break;
  235.       /* template additions */
  236.       case 't':
  237.         p += 1;
  238.         {
  239. !     int r, i;
  240. !     int non_empty = 0;
  241.       string tname;
  242.       string trawname;
  243.       
  244. -     string temp;
  245. -     int need_comma = 0;
  246. -     
  247.       string_init(&tname);
  248.       string_init(&trawname);
  249. !     
  250.       /* get template name */
  251.       if (!get_simple_count (&p, &r))
  252.         {
  253. !         string_delete (&decl);
  254. !         return 0;
  255.         }
  256.       string_appendn (&tname, p, r);
  257.       string_appendn (&trawname, p, r);
  258. -     string_appendn (&trawname, "", 1);
  259.       p += r;
  260.       string_append (&tname, "<");
  261. !     /* get size of template parameter list */
  262. !     if (!get_count (&p, &r))
  263. !       return 0;
  264. !     for (i = 0; i < r; i++)
  265.         {
  266. !         if (need_comma)
  267. !           string_append (&tname, ", ");
  268. !         /* Z for type parameters */
  269. !         if (*p == 'Z')
  270. !           {
  271. !         p += 1;
  272. !         
  273. !         success = do_type (&p, &temp);
  274. !         string_appendn (&temp, "", 1);
  275. !         if (success)
  276. !           string_append (&tname, temp.b);
  277. !         string_delete(&temp);
  278. !         if (!success)
  279. !           break;
  280. !           }
  281. !         /* otherwise, value parameter */
  282. !         else
  283. !           {
  284. !         const char *old_p  = p;
  285. !         int is_pointer = 0;
  286. !         int is_real = 0;
  287. !         int is_integral = 0;
  288. !         int done = 0;
  289. ! 
  290. !         success = do_type (&p, &temp);
  291. !         string_appendn (&temp, "", 1);
  292. !         if (success)
  293. !           string_append (&tname, temp.b);
  294. !         string_delete(&temp);
  295. !         if (!success)
  296. !           break;
  297. !         string_append (&tname, "=");
  298. !         while (*old_p && !done)
  299. !           {    
  300. !             switch (*old_p)
  301. !               {
  302. !               case 'P':
  303. !               case 'R':
  304. !             done = is_pointer = 1;
  305. !             break;
  306. !               case 'C':    /* const */
  307. !               case 'U':    /* unsigned */
  308. !               case 'V':    /* volatile */
  309. !               case 'F':    /* function */
  310. !               case 'M':    /* member function */
  311. !               case 'O':    /* ??? */
  312. !             old_p++;
  313. !             continue;
  314. !               case 'Q':    /* repetition of following */
  315. !               case 'T':    /* remembered type */
  316. !             abort();
  317. !             break;
  318. !               case 'v':    /* void */
  319. !             abort();
  320. !             break;
  321. !               case 'x':    /* long long */
  322. !               case 'l':    /* long */
  323. !               case 'i':    /* int */
  324. !               case 's':    /* short */
  325. !               case 'c':    /* char */
  326. !             done = is_integral = 1;
  327. !             break;
  328. !               case 'r':    /* long double */
  329. !               case 'd':    /* double */
  330. !               case 'f':    /* float */
  331. !             done = is_real = 1;
  332. !             break;
  333. !               default:
  334. !             abort();
  335. !               }
  336. !           }
  337. !         if (is_integral)
  338. !           {
  339. !             if (*p == 'm')
  340. !               {
  341. !             string_appendn (&tname, "-", 1);
  342. !             p++;
  343. !               }
  344. !             while (isdigit (*p))    
  345. !               {
  346. !             string_appendn (&tname, p, 1);
  347. !             p++;
  348. !               }
  349. !           }
  350. !         else if (is_real)
  351. !           {
  352. !             if (*p == 'm')
  353. !               {
  354. !             string_appendn (&tname, "-", 1);
  355. !             p++;
  356. !               }
  357. !             while (isdigit (*p))    
  358. !               {
  359. !             string_appendn (&tname, p, 1);
  360. !             p++;
  361. !               }
  362. !             if (*p == '.') /* fraction */
  363. !               {
  364. !             string_appendn (&tname, ".", 1);
  365. !             p++;
  366. !             while (isdigit (*p))    
  367. !               {
  368. !                 string_appendn (&tname, p, 1);
  369. !                 p++;
  370. !               }
  371. !               }
  372. !             if (*p == 'e') /* exponent */
  373. !               {
  374. !             string_appendn (&tname, "e", 1);
  375. !             p++;
  376. !             while (isdigit (*p))    
  377. !               {
  378. !                 string_appendn (&tname, p, 1);
  379. !                 p++;
  380. !               }
  381. !               }
  382. !           }
  383. !         else if (is_pointer)
  384. !           {
  385. !             int symbol_len;
  386. !             
  387. !             if (!get_count (&p, &symbol_len))
  388. !               {
  389. !             success = 0;
  390. !             break;
  391. !               }
  392. !             string_appendn (&tname, p, symbol_len);
  393. !             p += symbol_len;
  394. !           }
  395. !           }
  396. !         need_comma = 1;
  397.         }
  398.       string_append (&tname, ">::");
  399.       if (destructor)
  400.         string_append(&tname, "~");
  401. !     if (constructor || destructor) {
  402. !       string_appendn (&trawname, "", 1);
  403. !       string_append (&tname, trawname.b);
  404. !     }
  405.       string_delete(&trawname);
  406. !     
  407.       if (!success) {
  408.         string_delete(&tname);
  409.         return 0;
  410.       }
  411. !     string_appendn (&tname, "", 1);
  412. !     string_prepend (&decl, tname.b);
  413.       string_delete (&tname);
  414.   
  415.       if (static_type)
  416. --- 424,468 ----
  417.         break;
  418.       /* template additions */
  419.       case 't':
  420. +     template:
  421.         p += 1;
  422.         {
  423. !     int r;
  424.       string tname;
  425.       string trawname;
  426.       
  427.       string_init(&tname);
  428.       string_init(&trawname);
  429. ! 
  430.       /* get template name */
  431.       if (!get_simple_count (&p, &r))
  432.         {
  433. !         success = 0;
  434. !         break;
  435.         }
  436.       string_appendn (&tname, p, r);
  437.       string_appendn (&trawname, p, r);
  438.       p += r;
  439.       string_append (&tname, "<");
  440. !     success = do_template_args (&p, &tname);
  441. !     if (!success)
  442.         {
  443. !         string_delete (&tname);
  444. !         string_delete (&trawname);
  445. !         break;
  446.         }
  447.       string_append (&tname, ">::");
  448.       if (destructor)
  449.         string_append(&tname, "~");
  450. !     if (constructor || destructor)
  451. !       string_appends (&tname, &trawname);
  452.       string_delete(&trawname);
  453. ! 
  454.       if (!success) {
  455.         string_delete(&tname);
  456.         return 0;
  457.       }
  458. !     string_prepends (&decl, &tname);
  459.       string_delete (&tname);
  460.   
  461.       if (static_type)
  462. ***************
  463. *** 602,609 ****
  464.         }
  465.       else
  466.         success = do_args (&p, &decl);
  467. !     break;
  468.         }
  469.       }
  470.   
  471.     for (i = 0; i < ntypes; i++)
  472. --- 473,482 ----
  473.         }
  474.       else
  475.         success = do_args (&p, &decl);
  476. !     if (const_flag)
  477. !       string_append (&decl, " const");
  478.         }
  479. +       break;
  480.       }
  481.   
  482.     for (i = 0; i < ntypes; i++)
  483. ***************
  484. *** 686,692 ****
  485.       case 'Q':
  486.         n = (*type)[1] - '0';
  487.         if (n < 0 || n > 9)
  488. !         success = 0;
  489.         *type += 2;
  490.         while (n-- > 0)
  491.           do_type (type, result);
  492. --- 559,568 ----
  493.       case 'Q':
  494.         n = (*type)[1] - '0';
  495.         if (n < 0 || n > 9)
  496. !         {
  497. !           success = 0;
  498. !           break;
  499. !         }
  500.         *type += 2;
  501.         while (n-- > 0)
  502.           do_type (type, result);
  503. ***************
  504. *** 842,850 ****
  505.       }
  506.   }
  507.   
  508. ! int
  509.   do_cuv_prefix (type, result, non_empty)
  510. !      char **type;
  511.        string* result;
  512.        int* non_empty;
  513.   {
  514. --- 718,726 ----
  515.       }
  516.   }
  517.   
  518. ! static int
  519.   do_cuv_prefix (type, result, non_empty)
  520. !      const char **type;
  521.        string* result;
  522.        int* non_empty;
  523.   {
  524. ***************
  525. *** 887,895 ****
  526.     return success;
  527.   }
  528.   
  529. ! int
  530.   do_builtin_type (type, result, non_empty)
  531. !      char **type;
  532.        string* result;
  533.        int *non_empty;
  534.   {
  535. --- 763,771 ----
  536.     return success;
  537.   }
  538.   
  539. ! static int
  540.   do_builtin_type (type, result, non_empty)
  541. !      const char **type;
  542.        string* result;
  543.        int *non_empty;
  544.   {
  545. ***************
  546. *** 991,996 ****
  547. --- 867,890 ----
  548.         string_appendn (result, *type, n);
  549.         *type += n;
  550.         break;
  551. +     case 't':
  552. +       *type += 1;
  553. +       /* get template name */
  554. +       if (!get_simple_count (type, &n))
  555. +     {
  556. +       success = 0;
  557. +       break;
  558. +     }
  559. +       if (*non_empty)
  560. +     string_append (result, " ");
  561. +       string_appendn (result, *type, n);
  562. +       *type += n;
  563. +       string_append (result, "<");
  564. +       if (!do_template_args (type, result))
  565. +     success = 0;
  566. +       else
  567. +     string_append (result, ">");
  568. +       break;
  569.       default:
  570.         success = 0;
  571.         break;
  572. ***************
  573. *** 998,1003 ****
  574. --- 892,1045 ----
  575.     return success;
  576.   }
  577.   
  578. + static int
  579. + do_template_args (type, result)
  580. +      const char **type;
  581. +      string *result;
  582. + {
  583. +   int r, i;
  584. + 
  585. +   string temp;
  586. +   int need_comma = 0;
  587. +   int success;
  588. + 
  589. +   /* get size of template parameter list */
  590. +   if (!get_count (type, &r))
  591. +     return 0;
  592. +   for (i = 0; i < r; i++)
  593. +     {
  594. +       if (need_comma)
  595. +     string_append (result, ", ");
  596. +       /* Z for type parameters */
  597. +       if (**type == 'Z')
  598. +     {
  599. +       *type += 1;
  600. + 
  601. +       success = do_type (type, &temp);
  602. +       if (success)
  603. +         string_appends (result, &temp);
  604. +       string_delete(&temp);
  605. +       if (!success)
  606. +         break;
  607. +     }
  608. +       /* otherwise, value parameter */
  609. +       else
  610. +     {
  611. +       const char *old_p  = *type;
  612. +       int is_pointer = 0;
  613. +       int is_real = 0;
  614. +       int is_integral = 0;
  615. +       int done = 0;
  616. + 
  617. +       success = do_type (type, &temp);
  618. +       if (success)
  619. +         string_appends (result, &temp);
  620. +       string_delete(&temp);
  621. +       if (!success)
  622. +         break;
  623. +       string_append (result, "=");
  624. +       while (*old_p && !done)
  625. +         {    
  626. +           switch (*old_p)
  627. +         {
  628. +         case 'P':
  629. +         case 'R':
  630. +           done = is_pointer = 1;
  631. +           break;
  632. +         case 'C':    /* const */
  633. +         case 'U':    /* unsigned */
  634. +         case 'V':    /* volatile */
  635. +         case 'F':    /* function */
  636. +         case 'M':    /* member function */
  637. +         case 'O':    /* ??? */
  638. +           old_p++;
  639. +           continue;
  640. +         case 'Q':    /* repetition of following */
  641. +         case 'T':    /* remembered type */
  642. +           abort();
  643. +           break;
  644. +         case 'v':    /* void */
  645. +           abort();
  646. +           break;
  647. +         case 'x':    /* long long */
  648. +         case 'l':    /* long */
  649. +         case 'i':    /* int */
  650. +         case 's':    /* short */
  651. +         case 'c':    /* char */
  652. +           done = is_integral = 1;
  653. +           break;
  654. +         case 'r':    /* long double */
  655. +         case 'd':    /* double */
  656. +         case 'f':    /* float */
  657. +           done = is_real = 1;
  658. +           break;
  659. +         default:
  660. +           abort();
  661. +         }
  662. +         }
  663. +       if (is_integral)
  664. +         {
  665. +           if (**type == 'm')
  666. +         {
  667. +           string_appendn (result, "-", 1);
  668. +           *type++;
  669. +         }
  670. +           while (isdigit (**type))    
  671. +         {
  672. +           string_appendn (result, *type, 1);
  673. +           *type++;
  674. +         }
  675. +         }
  676. +       else if (is_real)
  677. +         {
  678. +           if (**type == 'm')
  679. +         {
  680. +           string_appendn (result, "-", 1);
  681. +           *type++;
  682. +         }
  683. +           while (isdigit (**type))    
  684. +         {
  685. +           string_appendn (result, *type, 1);
  686. +           *type++;
  687. +         }
  688. +           if (**type == '.')    /* fraction */
  689. +         {
  690. +           string_appendn (result, ".", 1);
  691. +           *type++;
  692. +           while (isdigit (**type))    
  693. +             {
  694. +               string_appendn (result, *type, 1);
  695. +               *type++;
  696. +             }
  697. +         }
  698. +           if (**type == 'e')    /* exponent */
  699. +         {
  700. +           string_appendn (result, "e", 1);
  701. +           *type++;
  702. +           while (isdigit (**type))    
  703. +             {
  704. +               string_appendn (result, *type, 1);
  705. +               *type++;
  706. +             }
  707. +         }
  708. +         }
  709. +       else if (is_pointer)
  710. +         {
  711. +           int symbol_len;
  712. + 
  713. +           if (!get_count (type, &symbol_len))
  714. +         {
  715. +           success = 0;
  716. +           break;
  717. +         }
  718. +           string_appendn (result, *type, symbol_len);
  719. +           *type += symbol_len;
  720. +         }
  721. +     }
  722. +       need_comma = 1;
  723. +     }
  724. + }
  725. + 
  726.   /* `result' will be initialised in do_type; it will be freed on failure */
  727.   
  728.   static int
  729. ***************
  730. *** 1321,1327 ****
  731.     string_prependn (p, s, strlen (s));
  732.   }
  733.   
  734. - #if 0
  735.   static void
  736.   string_prepends (p, s)
  737.        string *p, *s;
  738. --- 1363,1368 ----
  739. ***************
  740. *** 1330,1336 ****
  741.       return;
  742.     string_prependn (p, s->b, s->p - s->b);
  743.   }
  744. - #endif
  745.   
  746.   static void
  747.   string_prependn (p, s, n)
  748. --- 1371,1376 ----
  749. *** 1.31    1992/03/22 21:44:03
  750. --- ld.c    1992/04/19 17:00:16
  751. ***************
  752. *** 468,474 ****
  753.   #define RELOC_TYPE(r)        ((r)->r_symbolnum)
  754.   #define RELOC_SYMBOL(r)        ((r)->r_symbolnum)
  755.   #define RELOC_MEMORY_ADD_P(r)    1
  756. ! /* #define RELOC_ADD_EXTRA(r)        0       /* Don't need to define */
  757.   #define RELOC_PCREL_P(r)        ((r)->r_pcrel)
  758.   #define RELOC_VALUE_RIGHTSHIFT(r)    0
  759.   #define RELOC_TARGET_SIZE(r)        ((r)->r_length)
  760. --- 468,474 ----
  761.   #define RELOC_TYPE(r)        ((r)->r_symbolnum)
  762.   #define RELOC_SYMBOL(r)        ((r)->r_symbolnum)
  763.   #define RELOC_MEMORY_ADD_P(r)    1
  764. ! /* #define RELOC_ADD_EXTRA(r)        0     */ /* Don't need to define */
  765.   #define RELOC_PCREL_P(r)        ((r)->r_pcrel)
  766.   #define RELOC_VALUE_RIGHTSHIFT(r)    0
  767.   #define RELOC_TARGET_SIZE(r)        ((r)->r_length)
  768. ***************
  769. *** 1108,1119 ****
  770.   void fatal_with_file P_((char *string, struct file_entry *entry));
  771.   void perror_name P_((char *name));
  772.   void perror_file P_((struct file_entry *entry));
  773. ! void mywrite P_((char *buf, int count, int eltsize, FILE *desc));
  774.   void padfile P_((int padding, FILE *outdesc));
  775.   char *concat P_((char *s1, char *s2, char *s3));
  776.   int parse P_((char *arg, char *format, char *error));
  777. ! int xmalloc P_((int size));
  778. ! int xrealloc P_((char *ptr, int size));
  779.   int write_minix_sym P_((struct nlist *p, char *str, int gflag, int fflag));
  780.   void write_minix_syms P_((struct file_entry *entry, int *syms_written_addr));
  781.   void do_write_minix_out P_((void));
  782. --- 1108,1119 ----
  783.   void fatal_with_file P_((char *string, struct file_entry *entry));
  784.   void perror_name P_((char *name));
  785.   void perror_file P_((struct file_entry *entry));
  786. ! void mywrite P_((void *buf, int count, int eltsize, FILE *desc));
  787.   void padfile P_((int padding, FILE *outdesc));
  788.   char *concat P_((char *s1, char *s2, char *s3));
  789.   int parse P_((char *arg, char *format, char *error));
  790. ! void *xmalloc P_((int size));
  791. ! void *xrealloc P_((void *ptr, int size));
  792.   int write_minix_sym P_((struct nlist *p, char *str, int gflag, int fflag));
  793.   void write_minix_syms P_((struct file_entry *entry, int *syms_written_addr));
  794.   void do_write_minix_out P_((void));
  795. ***************
  796. *** 1125,1131 ****
  797.   #ifndef bcopy
  798.   void bcopy (), bzero ();
  799.   #endif
  800. ! int malloc (), realloc ();
  801.   #ifndef alloca
  802.   int alloca ();
  803.   #endif
  804. --- 1125,1131 ----
  805.   #ifndef bcopy
  806.   void bcopy (), bzero ();
  807.   #endif
  808. ! void *malloc (), *realloc ();
  809.   #ifndef alloca
  810.   int alloca ();
  811.   #endif
  812. ***************
  813. *** 1159,1165 ****
  814.   
  815.     /* Initialize the data about options.  */
  816.   
  817. ! #ifdef atarist
  818.     gst_symboltable = 0;
  819.     gst_symbols = 0;
  820.   #endif
  821. --- 1159,1165 ----
  822.   
  823.     /* Initialize the data about options.  */
  824.   
  825. ! #if defined(atarist) || defined(CROSSATARI)
  826.     gst_symboltable = 0;
  827.     gst_symbols = 0;
  828.   #endif
  829. ***************
  830. *** 1573,1579 ****
  831.                    /* else  "*(cpp = cp) = '\0'"  =>> end */
  832.            n_search_dirs++;
  833.            search_dirs =
  834. !          (char **) xrealloc(search_dirs, n_search_dirs*sizeof(char *));
  835.            search_dirs[n_search_dirs-1] = concat(cpp, "", "");
  836.   #ifdef DEBUG
  837.            fprintf(stderr, "... '%s'\n", search_dirs[n_search_dirs-1]);
  838. --- 1573,1580 ----
  839.                    /* else  "*(cpp = cp) = '\0'"  =>> end */
  840.            n_search_dirs++;
  841.            search_dirs =
  842. !          (char **) xrealloc((char *)search_dirs,
  843. !                     n_search_dirs*sizeof(char *));
  844.            search_dirs[n_search_dirs-1] = concat(cpp, "", "");
  845.   #ifdef DEBUG
  846.            fprintf(stderr, "... '%s'\n", search_dirs[n_search_dirs-1]);
  847. ***************
  848. *** 1590,1596 ****
  849.       int n = sizeof standard_search_dirs / sizeof standard_search_dirs[0];
  850.       n_search_dirs += n;
  851.       search_dirs
  852. !       = (char **) xrealloc (search_dirs, n_search_dirs * sizeof (char *));
  853.       bcopy (standard_search_dirs, &search_dirs[n_search_dirs - n],
  854.          n * sizeof (char *));
  855.     }
  856. --- 1591,1598 ----
  857.       int n = sizeof standard_search_dirs / sizeof standard_search_dirs[0];
  858.       n_search_dirs += n;
  859.       search_dirs
  860. !       = (char **) xrealloc ((char *)search_dirs,
  861. !                 n_search_dirs * sizeof (char *));
  862.       bcopy (standard_search_dirs, &search_dirs[n_search_dirs - n],
  863.          n * sizeof (char *));
  864.     }
  865. ***************
  866. *** 1614,1620 ****
  867.         
  868.         cl_refs_allocated *= 2;
  869.         cmdline_references = (struct glosym **)
  870. !     xrealloc (cmdline_references,
  871.            cl_refs_allocated * sizeof (struct glosym *));
  872.         ptr = cmdline_references + diff;
  873.       }
  874. --- 1616,1622 ----
  875.         
  876.         cl_refs_allocated *= 2;
  877.         cmdline_references = (struct glosym **)
  878. !     xrealloc ((char *)cmdline_references,
  879.            cl_refs_allocated * sizeof (struct glosym *));
  880.         ptr = cmdline_references + diff;
  881.       }
  882. ***************
  883. *** 1690,1696 ****
  884.       case 'L':
  885.         n_search_dirs++;
  886.         search_dirs
  887. !     = (char **) xrealloc (search_dirs, n_search_dirs * sizeof (char *));
  888.         search_dirs[n_search_dirs - 1] = arg;
  889.         return;
  890.   
  891. --- 1692,1699 ----
  892.       case 'L':
  893.         n_search_dirs++;
  894.         search_dirs
  895. !     = (char **) xrealloc ((char *)search_dirs,
  896. !                   n_search_dirs * sizeof (char *));
  897.         search_dirs[n_search_dirs - 1] = arg;
  898.         return;
  899.   
  900. ***************
  901. *** 1902,1908 ****
  902.   file_open (entry)
  903.        register struct file_entry *entry;
  904.   {
  905. !   register FILE *desc;
  906.   
  907.     if (entry->superfile)
  908.       return file_open (entry->superfile);
  909. --- 1905,1911 ----
  910.   file_open (entry)
  911.        register struct file_entry *entry;
  912.   {
  913. !   register FILE *desc = NULL;
  914.   
  915.     if (entry->superfile)
  916.       return file_open (entry->superfile);
  917. ***************
  918. *** 3228,3234 ****
  919.     fprintf (outfile, "  ");
  920.     print_file_name (entry, outfile);
  921.     if (entry->just_syms_flag)
  922. !     fprintf (outfile, " symbols only\n", 0);
  923.     else
  924.       fprintf (outfile, " text %x(%x), data %x(%x), bss %x(%x) hex\n",
  925.            entry->text_start_address, entry->header.a_text,
  926. --- 3231,3237 ----
  927.     fprintf (outfile, "  ");
  928.     print_file_name (entry, outfile);
  929.     if (entry->just_syms_flag)
  930. !     fprintf (outfile, " symbols only\n");
  931.     else
  932.       fprintf (outfile, " text %x(%x), data %x(%x), bss %x(%x) hex\n",
  933.            entry->text_start_address, entry->header.a_text,
  934. ***************
  935. *** 3987,3993 ****
  936.   #endif /* BYTE_SWAP */
  937.   
  938.   # ifndef WORD_ALIGNED
  939. !   mywrite (&outheader, sizeof outheader, 1, outdesc);
  940.   # else
  941.   #  ifndef MINIX
  942.        mywrite (&outheader.a_magic  , sizeof outheader.a_magic  , 1, outdesc);
  943. --- 3990,3996 ----
  944.   #endif /* BYTE_SWAP */
  945.   
  946.   # ifndef WORD_ALIGNED
  947. !   mywrite ((char *)&outheader, sizeof outheader, 1, outdesc);
  948.   # else
  949.   #  ifndef MINIX
  950.        mywrite (&outheader.a_magic  , sizeof outheader.a_magic  , 1, outdesc);
  951. ***************
  952. *** 4046,4052 ****
  953.     /* Write out the set element vectors */
  954.   
  955.     if (set_vector_count)
  956. !     mywrite (set_vectors, set_symbol_count + 2 * set_vector_count, sizeof (unsigned long), outdesc);
  957.   
  958.     if (trace_files)
  959.       fprintf (stderr, "\n");
  960. --- 4049,4057 ----
  961.     /* Write out the set element vectors */
  962.   
  963.     if (set_vector_count)
  964. !     mywrite ((char *) set_vectors,
  965. !          set_symbol_count + 2 * set_vector_count,
  966. !          sizeof (unsigned long), outdesc);
  967.   
  968.     if (trace_files)
  969.       fprintf (stderr, "\n");
  970. ***************
  971. *** 4350,4356 ****
  972.         relocation >>= RELOC_VALUE_RIGHTSHIFT(p);
  973.   
  974.         /* Unshifted mask for relocation */
  975. !       mask = 1 << RELOC_TARGET_BITSIZE(p) - 1;
  976.         mask |= mask - 1;
  977.         relocation &= mask;
  978.   
  979. --- 4355,4361 ----
  980.         relocation >>= RELOC_VALUE_RIGHTSHIFT(p);
  981.   
  982.         /* Unshifted mask for relocation */
  983. !       mask = 1 << (RELOC_TARGET_BITSIZE(p) - 1);
  984.         mask |= mask - 1;
  985.         relocation &= mask;
  986.   
  987. ***************
  988. *** 4763,4773 ****
  989.     sym.a_value = p->n_value;
  990.   
  991.   #ifndef WORD_ALIGNED
  992. !   mywrite(&sym, sizeof sym, 1, outdesc);
  993.     if (i > 0)
  994.       {
  995.         (void) strncpy ((char *) &sym, str, (size_t)i);
  996. !       mywrite(&sym, sizeof sym, 1, outdesc);
  997.       }
  998.   #else
  999.     mywrite(sym.a_name , sizeof sym.a_name , 1, outdesc);
  1000. --- 4768,4778 ----
  1001.     sym.a_value = p->n_value;
  1002.   
  1003.   #ifndef WORD_ALIGNED
  1004. !   mywrite((char *)&sym, sizeof sym, 1, outdesc);
  1005.     if (i > 0)
  1006.       {
  1007.         (void) strncpy ((char *) &sym, str, (size_t)i);
  1008. !       mywrite((char *)&sym, sizeof sym, 1, outdesc);
  1009.       }
  1010.   #else
  1011.     mywrite(sym.a_name , sizeof sym.a_name , 1, outdesc);
  1012. ***************
  1013. *** 5742,5748 ****
  1014.   
  1015.   void
  1016.   mywrite (buf, count, eltsize, desc)
  1017. !      char *buf;
  1018.        int count;
  1019.        int eltsize;
  1020.        FILE *desc;
  1021. --- 5747,5753 ----
  1022.   
  1023.   void
  1024.   mywrite (buf, count, eltsize, desc)
  1025. !      void *buf;
  1026.        int count;
  1027.        int eltsize;
  1028.        FILE *desc;
  1029. ***************
  1030. *** 5808,5818 ****
  1031.   
  1032.   /* Like malloc but get fatal error if memory is exhausted.  */
  1033.   
  1034. ! int
  1035.   xmalloc (size)
  1036.        int size;
  1037.   {
  1038. !   register int result = malloc (size);
  1039.     if (!result)
  1040.       fatal ("virtual memory exhausted", 0);
  1041.     return result;
  1042. --- 5813,5823 ----
  1043.   
  1044.   /* Like malloc but get fatal error if memory is exhausted.  */
  1045.   
  1046. ! void *
  1047.   xmalloc (size)
  1048.        int size;
  1049.   {
  1050. !   register void *result = malloc (size);
  1051.     if (!result)
  1052.       fatal ("virtual memory exhausted", 0);
  1053.     return result;
  1054. ***************
  1055. *** 5820,5831 ****
  1056.   
  1057.   /* Like realloc but get fatal error if memory is exhausted.  */
  1058.   
  1059. ! int
  1060.   xrealloc (ptr, size)
  1061. !      char *ptr;
  1062.        int size;
  1063.   {
  1064. !   register int result = realloc (ptr, size);
  1065.     if (!result)
  1066.       fatal ("virtual memory exhausted", 0);
  1067.     return result;
  1068. --- 5825,5836 ----
  1069.   
  1070.   /* Like realloc but get fatal error if memory is exhausted.  */
  1071.   
  1072. ! void *
  1073.   xrealloc (ptr, size)
  1074. !      void *ptr;
  1075.        int size;
  1076.   {
  1077. !   register void *result = realloc (ptr, size);
  1078.     if (!result)
  1079.       fatal ("virtual memory exhausted", 0);
  1080.     return result;
  1081. *** 1.5    1992/01/14 19:45:23
  1082. --- strip.c    1992/04/19 17:00:18
  1083. ***************
  1084. *** 49,57 ****
  1085.   
  1086.   #include <fcntl.h>
  1087.   
  1088. - #ifdef __GNUC__
  1089. - #define NULL        ((void *)0)
  1090. - #endif
  1091.   #define NEWBUFSIZ    16384L
  1092.   
  1093.   char            mybuf[NEWBUFSIZ];
  1094. --- 49,54 ----
  1095. ***************
  1096. *** 58,67 ****
  1097.   char            tmpname[128];
  1098.   
  1099.   #define SYMLEN 8
  1100.   
  1101. ! typedef char    symstr_t[SYMLEN];
  1102. ! symstr_t        stklist[] = {{'_', '_', 's', 't', 'k', 's', 'i', 'z',},
  1103. !                  {'\0'}};
  1104.   
  1105.   #ifdef atarist
  1106.   long            _stksize = 1L;
  1107. --- 55,64 ----
  1108.   char            tmpname[128];
  1109.   
  1110.   #define SYMLEN 8
  1111. + #define GST_SYMLEN 22
  1112.   
  1113. ! typedef char    symstr_t[GST_SYMLEN];
  1114. ! symstr_t        stklist[] = {"__stksize", "__initial_stack"};
  1115.   
  1116.   #ifdef atarist
  1117.   long            _stksize = 1L;
  1118. ***************
  1119. *** 124,130 ****
  1120.           --argc;
  1121.           argv++;
  1122.           }
  1123. !         if ((symstr_t *) 0 == (nmlist = mklist (*argv)))
  1124.           usage ("cannot create a list of reserved names\r\n");
  1125.           select = sel_listed;
  1126.           break;
  1127. --- 121,127 ----
  1128.           --argc;
  1129.           argv++;
  1130.           }
  1131. !         if ((symstr_t *) NULL == (nmlist = mklist (*argv)))
  1132.           usage ("cannot create a list of reserved names\r\n");
  1133.           select = sel_listed;
  1134.           break;
  1135. ***************
  1136. *** 227,233 ****
  1137.   
  1138.   #if !__STDC__ && !__cplusplus
  1139.   #  ifndef offsetof
  1140. ! #    define offsetof(TYPE, MEMBER) ((unsigned long) &((TYPE *)0)->MEMBER)
  1141.   #  endif
  1142.   #  ifndef CROSSHPUX
  1143.        typedef unsigned long size_t;
  1144. --- 224,230 ----
  1145.   
  1146.   #if !__STDC__ && !__cplusplus
  1147.   #  ifndef offsetof
  1148. ! #    define offsetof(TYPE, MEMBER) ((unsigned long) &((TYPE *)0L)->MEMBER)
  1149.   #  endif
  1150.   #  ifndef CROSSHPUX
  1151.        typedef unsigned long size_t;
  1152. ***************
  1153. *** 305,311 ****
  1154.       close (fd);
  1155.       return 0x80;
  1156.       }
  1157. !     if ((long(*)())0 == select) {     /* remove whole symbol table */
  1158.       lbytes = 0L;
  1159.       if (lseek (fd, sbytes, 1) < 0) {
  1160.           report (name);
  1161. --- 302,308 ----
  1162.       close (fd);
  1163.       return 0x80;
  1164.       }
  1165. !     if (NULL == select) {     /* remove whole symbol table */
  1166.       lbytes = 0L;
  1167.       if (lseek (fd, sbytes, 1) < 0) {
  1168.           report (name);
  1169. ***************
  1170. *** 410,416 ****
  1171.   char * fname;
  1172.   {
  1173.       FILE           *fp;
  1174. !     symstr_t       *list = (symstr_t *) 0;
  1175.       int             left = 0;
  1176.       int             pos = 0;
  1177.       int             i;
  1178. --- 407,413 ----
  1179.   char * fname;
  1180.   {
  1181.       FILE           *fp;
  1182. !     symstr_t       *list = (symstr_t *) NULL;
  1183.       int             left = 0;
  1184.       int             pos = 0;
  1185.       int             i;
  1186. ***************
  1187. *** 418,424 ****
  1188. --- 415,425 ----
  1189.       char            lbuf[LBUFSIZE];
  1190.       char           *in, *out;
  1191.   
  1192. + #ifdef atarist
  1193. +     if (NULL == (fp = fopen (fname, "rt"))) {
  1194. + #else
  1195.       if (NULL == (fp = fopen (fname, "r"))) {
  1196. + #endif
  1197.       report (fname);
  1198.       report (" -- ");
  1199.       usage ("cannot open this file\r\n");
  1200. ***************
  1201. *** 427,433 ****
  1202.       while (NULL != fgets (lbuf, LBUFSIZE, fp)) {
  1203.       if (0 == left) {
  1204.           max_size += NMSTEP;
  1205. !         if ((symstr_t *)0 == list) {
  1206.           list = (symstr_t *) malloc ( max_size * sizeof (symstr_t));
  1207.           }
  1208.           else {
  1209. --- 428,434 ----
  1210.       while (NULL != fgets (lbuf, LBUFSIZE, fp)) {
  1211.       if (0 == left) {
  1212.           max_size += NMSTEP;
  1213. !         if ((symstr_t *) NULL == list) {
  1214.           list = (symstr_t *) malloc ( max_size * sizeof (symstr_t));
  1215.           }
  1216.           else {
  1217. ***************
  1218. *** 435,441 ****
  1219.                            max_size * sizeof (symstr_t));
  1220.   
  1221.           }
  1222. !         if ((symstr_t *)0 == list) {
  1223.           report ("out of memory making symbol list\r\n");
  1224.           exit (-3);
  1225.           }
  1226. --- 436,442 ----
  1227.                            max_size * sizeof (symstr_t));
  1228.   
  1229.           }
  1230. !         if ((symstr_t *) NULL == list) {
  1231.           report ("out of memory making symbol list\r\n");
  1232.           exit (-3);
  1233.           }
  1234. ***************
  1235. *** 448,456 ****
  1236.       if ('\n' == *in)
  1237.           continue;        /* empty line - skip it */
  1238.       out = &list[pos][0];
  1239. !     for (i = SYMLEN; i > 0; --i) {
  1240.           if ('\n' == *in || ' ' == *in || '\t' == *in) {
  1241. !         *out = '\0';
  1242.           break;
  1243.           }
  1244.           *out++ = *in++;
  1245. --- 449,457 ----
  1246.       if ('\n' == *in)
  1247.           continue;        /* empty line - skip it */
  1248.       out = &list[pos][0];
  1249. !     for (i = GST_SYMLEN; i > 0; --i) {
  1250.           if ('\n' == *in || ' ' == *in || '\t' == *in) {
  1251. !         while (i-- > 0) *out++ = '\0';
  1252.           break;
  1253.           }
  1254.           *out++ = *in++;
  1255. ***************
  1256. *** 458,464 ****
  1257.       pos++;
  1258.       --left;
  1259.       }                /* while */
  1260. !     if ((symstr_t *)0 != list) {
  1261.       list[pos][0] = '\0';    /* terminate created list */
  1262.       }
  1263.       return (list);
  1264. --- 459,465 ----
  1265.       pos++;
  1266.       --left;
  1267.       }                /* while */
  1268. !     if ((symstr_t *) NULL != list) {
  1269.       list[pos][0] = '\0';    /* terminate created list */
  1270.       }
  1271.       return (list);
  1272. ***************
  1273. *** 530,536 ****
  1274.       symstr_t       *kname;
  1275.       struct asym     cur_sym, spare;
  1276.   
  1277. !     if ((symstr_t *) 0 == nmlist)
  1278.       return (0L);
  1279.   
  1280.       while (sbytes) {
  1281. --- 531,537 ----
  1282.       symstr_t       *kname;
  1283.       struct asym     cur_sym, spare;
  1284.   
  1285. !     if ((symstr_t *) NULL == nmlist)
  1286.       return (0L);
  1287.   
  1288.       while (sbytes) {
  1289. ***************
  1290. *** 541,548 ****
  1291.       }
  1292.       for (kname = nmlist; '\0' != **kname; kname++) {
  1293.           if (0 == strncmp (&(*kname)[0], &cur_sym.a_name[0], SYMLEN)) {
  1294. !         if (A_LNAM & cur_sym.a_type) { /* if extended */
  1295. !             cur_sym.a_type ^= A_LNAM;
  1296.               if ((long)SIZEOF_ASYM != lread (fd, &spare,
  1297.                           (long)SIZEOF_ASYM)) {
  1298.               report ("error on reading symbol table\r\n");
  1299. --- 542,548 ----
  1300.       }
  1301.       for (kname = nmlist; '\0' != **kname; kname++) {
  1302.           if (0 == strncmp (&(*kname)[0], &cur_sym.a_name[0], SYMLEN)) {
  1303. !         if ((A_LNAM & cur_sym.a_type) == A_LNAM) { /* if extended */
  1304.               if ((long)SIZEOF_ASYM != lread (fd, &spare,
  1305.                           (long)SIZEOF_ASYM)) {
  1306.               report ("error on reading symbol table\r\n");
  1307. ***************
  1308. *** 549,554 ****
  1309. --- 549,557 ----
  1310.               goto leave;  /* skip two loop levels */
  1311.               }
  1312.               sbytes -= SIZEOF_ASYM;
  1313. +             if (strncmp (&(*kname)[SYMLEN], (char *)&spare,
  1314. +                  GST_SYMLEN-SYMLEN))
  1315. +               continue;
  1316.           }
  1317.           if ((long)SIZEOF_ASYM != lwrite (tfd, &cur_sym,
  1318.                           (long)SIZEOF_ASYM)) {
  1319. ***************
  1320. *** 555,560 ****
  1321. --- 558,572 ----
  1322.               report ("error on writing symbol table\r\n");
  1323.               goto leave;
  1324.           }
  1325. +         if ((cur_sym.a_type & A_LNAM) == A_LNAM)
  1326. +           {
  1327. +             if (lwrite (tfd, &spare, (long)SIZEOF_ASYM) != SIZEOF_ASYM)
  1328. +               {
  1329. +             report ("error on writing symbol table\r\n");
  1330. +             goto leave;
  1331. +               }
  1332. +             lbytes += SIZEOF_ASYM;
  1333. +           }
  1334.           lbytes += SIZEOF_ASYM;
  1335.           break;
  1336.           }
  1337. ***************
  1338. *** 564,570 ****
  1339.   leave:
  1340.       if (nmlist != stklist) {
  1341.       free (nmlist);
  1342. !     nmlist = (symstr_t *) 0;
  1343.       }
  1344.       return (lbytes);
  1345.   }
  1346. --- 576,582 ----
  1347.   leave:
  1348.       if (nmlist != stklist) {
  1349.       free (nmlist);
  1350. !     nmlist = (symstr_t *) NULL;
  1351.       }
  1352.       return (lbytes);
  1353.   }
  1354. *** 1.17    1992/03/22 21:44:03
  1355. --- sym-ld.c    1992/04/19 17:00:19
  1356. ***************
  1357. *** 175,180 ****
  1358. --- 175,183 ----
  1359.   #    include <unistd.h>
  1360.   #  endif
  1361.   #endif        /* atarist */
  1362. + 
  1363. + #define ONLY_SYMBOLS
  1364. + 
  1365.   #endif
  1366.   
  1367.   /* If compiled with GNU C, use the built-in alloca */
  1368. ***************
  1369. *** 3439,3444 ****
  1370. --- 3442,3449 ----
  1371.     /* Output the a.out header.  */
  1372.     write_header ();
  1373.   
  1374. +   /* for the atari, we only want the symbols */
  1375. + #if !defined(ONLY_SYMBOLS)
  1376.     /* Output the text and data segments, relocating as we go.  */
  1377.     write_text ();
  1378.     write_data ();
  1379. ***************
  1380. *** 3446,3451 ****
  1381. --- 3451,3457 ----
  1382.     /* Output the merged relocation info, if requested with `-r'.  */
  1383.     if (relocatable_output)
  1384.       write_rel ();
  1385. + #endif
  1386.   
  1387.     /* Output the symbol table (both globals and locals).  */
  1388.     write_syms ();
  1389. ***************
  1390. *** 3466,3474 ****
  1391. --- 3472,3486 ----
  1392.   write_header ()
  1393.   {
  1394.     outheader.a_info = magic;
  1395. + #if defined(ONLY_SYMBOLS)
  1396. +   outheader.a_text = 0;
  1397. +   outheader.a_data = 0;
  1398. +   outheader.a_bss = 0;
  1399. + #else
  1400.     outheader.a_text = text_size;
  1401.     outheader.a_data = data_size;
  1402.     outheader.a_bss = bss_size;
  1403. + #endif
  1404.     outheader.a_entry = (entry_symbol ? entry_symbol->value
  1405.                  : text_start + entry_offset);
  1406.   #ifdef COFF_ENCAPSULATE
  1407. ***************
  1408. *** 3592,3597 ****
  1409. --- 3604,3610 ----
  1410.   #endif
  1411.   }
  1412.   
  1413. + #if !defined(ONLY_SYMBOLS)
  1414.   /* Relocate the text segment of each input file
  1415.      and write to the output file.  */
  1416.   
  1417. ***************
  1418. *** 3614,3619 ****
  1419. --- 3627,3633 ----
  1420.   
  1421.     padfile (text_pad, outdesc);
  1422.   }
  1423. + #endif /* !ONLY_SYMBOLS */
  1424.   
  1425.   int
  1426.   text_offset (entry)
  1427. ***************
  1428. *** 3670,3675 ****
  1429. --- 3684,3691 ----
  1430.       }
  1431.   }
  1432.   
  1433. + #if !defined(ONLY_SYMBOLS)
  1434. + 
  1435.   /* Read the text segment contents of ENTRY, relocate them,
  1436.      and write the result to the output file.
  1437.      If `-r', save the text relocation for later reuse.  */
  1438. ***************
  1439. *** 4073,4078 ****
  1440. --- 4089,4096 ----
  1441.       }
  1442.     mywrite (entry->datarel, 1, entry->header.a_drsize, outdesc);
  1443.   }
  1444. + 
  1445. + #endif /* !ONLY_SYMBOLS */
  1446.   
  1447.   void write_file_syms ();
  1448.   void write_string_table ();
  1449.